package com.winning.common.data.service;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.lang.reflect.Method;
import java.sql.Clob;
import java.sql.SQLException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import net.sf.json.JSONObject;

import oracle.sql.CLOB;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
import org.apache.log4j.Logger;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.quartz.CronTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerUtils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.cownew.ctk.common.RandomGUID;
import com.framework.helper.ServerSQLExecutorUtils;
import com.framework.server.db.bean.PageBean;
import com.framework.server.db.bean.PageQueryBean;
import com.winning.common.AppContext;
import com.winning.common.Constans;
import com.winning.common.beans.ihe.IHERequestBodyBean;
import com.winning.common.beans.ihe.IHERequestItemBean;
import com.winning.common.beans.xmlTemp.XMLTempBeanManager;
import com.winning.common.beans.xmlTemp.XMLTempConfigBean;
import com.winning.common.data.dao.impl.PlatBasicDataDao;
import com.winning.common.data.dao.inter.PlatBasicDataDaoInter;
import com.winning.common.tools.SQLTool;
import com.winning.common.tools.XMLTool;

/**
 * 类名称：PlatBasicDataService
 * 类描述：平台基础数据服务
 * 创建人：liuwensheng
 * 创建时间：2016-12-8 下午4:25:25
 * 修改人：liuwensheng
 * 修改时间：2016-12-8 下午4:25:25
 * 修改备注：
 */
@Service(value = "com.winning.lang.common.data.service.PlatBasicDataService")
public class PlatBasicDataService {
    private static Logger LOGGER = Logger.getLogger(Constans.LOG4J_PBS_LOGGER_ID);

    //个人信息注册id
    private static final String GRZC_SERVICE_ID = "GRZC_TEMP_001";

    @Autowired
    protected PlatBasicDataDaoInter platBasicDataDao = null;

    private HashMap<String, String> tableIncreaseTimeMapFromDB = null;

    /**
     * 查询患者信息 <br/>
     * 方法名称: getPatientPersionInfoDataHandler
     *
     * @param
     * @return List<Map                                                                                                                                                                                                                                                               <                                                                                                                                                                                                                                                               String                                                                                                                                                                                                                                                               ,                                                                                                                                                                                                                                                               Object>>  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-9/上午11:01:02<br/>
     */
    public List<Map<String, Object>> getPatientPersionInfoDataHandler() {
        List<Map<String, Object>> patientPersionInfoDataList = platBasicDataDao.getPatientPersionInfoDataService();
        return patientPersionInfoDataList;
    }

    /**
     * 根据提供的SQL获取平台基础数据源 <br/>
     * 方法名称: getPlatBasicDataBySQLService
     *
     * @param
     * @return List<JSONObject>  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-9/上午10:39:48<br/>
     */
    public List<Map<String, Object>> getPlatBasicDataBySQLService(String sql) {
        List<Map<String, Object>> result = platBasicDataDao.getPlatBasicDataBySQLService(sql);

        return result;
    }

    /**
     * 根据提供的SQL获取平台基础数据源，可指定数据库 <br/>
     * 方法名称: getPlatBasicDataByDataSourseIDHandler
     *
     * @param sql
     * @param dataSourseID 数据源ID
     * @return List<HashMap                                                                                                                                                                                                                                                               <                                                                                                                                                                                                                                                               String                                                                                                                                                                                                                                                               ,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Object>>  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-9/上午10:39:48<br/>
     */
    public List<HashMap<String, Object>> getPlatBasicDataByDataSourseIDHandler(String sql, String dataSourseID) {
        List<HashMap<String, Object>> result = platBasicDataDao.getPlatBasicDataByDataSourseIDService(sql, dataSourseID);

        return result;
    }

    /**
     * 解析XML行结果数据集，并处理最新的业务填报日期, 缓存在应用上下文中AppContext <br/>
     * 方法名称: paraseXMLToList
     *
     * @param
     * @return List<Map                                                                                                                                                                                                                                                               <                                                                                                                                                                                                                                                               String                                                                                                                                                                                                                                                               ,                                                                                                                                                                                                                                                               Object>>  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-13/下午4:25:41<br/>
     */
    private static List<Map<String, Object>> paraseXMLToList(String resultXML, String serviceID, String basicSQL) {
        //所有行数据列表:存放经过列表转换、字段值截取、字段值转义操作后的最新结果集
        List<Map<String, Object>> rowListValue = new ArrayList<Map<String, Object>>();

        Document messageDocument = XMLTool.getDocumentFromXMLString(resultXML, false);

        Element rootElement = messageDocument.getRootElement();

        List<Element> recordElementList = rootElement.elements();

        //循环遍历所有行
        for (Iterator<Element> recordElementIterator = recordElementList.iterator(); recordElementIterator.hasNext(); ) {
            Element recordElement = (Element) recordElementIterator.next();

            //解析表中一行数据的所有列
            List<Element> paramsElementList = recordElement.elements();

            //存放所有列的值
            HashMap<String, Object> columnObjectMap = new HashMap<String, Object>();

            //解析所有列
            for (Iterator<Element> paramElementIterator = paramsElementList.iterator(); paramElementIterator.hasNext(); ) {
                //列节点
                Element paramElement = (Element) paramElementIterator.next();

                //列名称
                String columnNameStr = paramElement.getName() == null ? "" : paramElement.getName().trim();

                //列的值
                Object valueObject = paramElement.getTextTrim();

                String columnValueStr = "";


                //统一将表字段值转换成String类型处理
                columnValueStr = valueObject == null ? "" : valueObject.toString();


                //列名字转换大写, 为了和配置文件一直
                String upperColumnNameStr = columnNameStr.toUpperCase();

                //存放业务数据值，KEY 为数据库列名称
                columnObjectMap.put(upperColumnNameStr, columnValueStr);

                //增加流程，沉淀每个业务表每条数据中的最新上报日期(tableName_TBRQ), 只有列名称中包含_TBRQ字段值，才做处理
                if (upperColumnNameStr.indexOf("_TBRQ") > -1) {
                    try {
                        SQLTool.sortDataTimeToLocal(serviceID, basicSQL, upperColumnNameStr, columnValueStr);
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                }
            }

            if (columnObjectMap != null) {

                //LOGGER.info("-->转换一行map信息:"+columnObjectMap.toString());
                //一行行保存
                rowListValue.add(columnObjectMap);
            }
        }

        return rowListValue;
    }

    /**
     * 支持增量流程的获取平台基础数据服务 <br/>
     * 方法名称: getPlatBasicDataByIncreaseTimeHandler
     *
     * @param dbDataSourseID 数据源ID
     * @param serviceID      服务ID，也可以理解为唯一标识符
     * @param basicSQL       基础查询SQL
     * @param pageNum
     * @param pageSize
     * @return List<Map                                                                                                                                                                                                                                                               <                                                                                                                                                                                                                                                               String                                                                                                                                                                                                                                                               ,                                                                                                                                                                                                                                                               Object>>  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-13/上午9:33:28<br/>
     */
    public List<Map<String, Object>> getPlatBasicDataByIncreaseTimeHandler(String dbDataSourseID, String serviceID, String basicSQL, int pageNum, int pageSize) {
        //1、从基础SQL中按照规则提取增量更新表名称，规则为TABLENAME_TBRQ，TBRQ是平台所有表必须有的字段
        HashMap<String, String> tableNameMap = SQLTool.getTableNameFromSQL(basicSQL);

        //2、获取业务库中保存的增量更新时间
        HashMap<String, String> tableValueMapFromDB = platBasicDataDao.getTableIncreaseTimeMapFromDB(dbDataSourseID);

        //3、增加增量流程的SQL
        String increaseSQLStr = SQLTool.createIncreaseSQL(serviceID, basicSQL, tableNameMap, tableValueMapFromDB);

        //4、查询业务库数据
        List<Map<String, Object>> resultList = null;

        //做分页处理
        PageBean pageBean = new PageBean();

        int pageNumValue = pageNum + 1;

        pageBean.setPageNum(pageNumValue);

        //必须要填的
        pageBean.setPageSize(pageSize);

        String orderStr = "";

        String tableDateName = SQLTool.getTableDateName(serviceID, tableNameMap);

        //时间进行排序，做增量更新
        if (tableDateName != null && tableDateName.length() > 0) {
            orderStr = " ORDER BY " + tableDateName + " ASC";
        }

        try {
            //多数据源支持
            PageQueryBean pageQueryBean = platBasicDataDao.getParamByPageQuery(pageBean, increaseSQLStr, orderStr, dbDataSourseID);

            LOGGER.info("--> Service ID:" + serviceID + "; 当前页码:[" + pageNumValue + "]; 分页查询SQL:[" + increaseSQLStr + orderStr + "]");

            if (pageQueryBean != null) {
                //数据库查询结果集采用XML结构返回
                String resultXML = pageQueryBean.getDataSet().toString();

                resultList = paraseXMLToList(resultXML, serviceID, basicSQL);

            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return resultList;
    }

    /**
     * 查询数据总量 <br/>
     * 方法名称: getPlatBasicDataCountHandler
     *
     * @param basicSQL
     * @param columnName   列名称
     * @param dataSourseID 数据源名称 默认数据源ID 为：Default_SQL_Dev
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-13/下午3:39:20<br/>
     */
    public int getPlatBasicDataCountHandler(String basicSQL, String columnName, String dataSourseID) {
        int result = platBasicDataDao.queryTotalDataCount(basicSQL, columnName, dataSourseID);

        return result;
    }


    /**
     * 模块初始化后，作业控制器初始化过程中，获取增量更新日期并缓存
     * 业务表的增量更新时间，以map结构缓存 <br/>
     * 方法名称: getTableIncreaseTimeMapFromDB
     *
     * @param
     * @return HashMap<String                                                                                                                                                                                                                                                               ,                                                                                                                                                                                                                                                               String>  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-13/上午8:48:51<br/>
     */
    public synchronized HashMap<String, String> getTableIncreaseTimeMapFromDB() {
        return tableIncreaseTimeMapFromDB;
    }

    /**
     * 更新本地缓存的增量更新日期 <br/>
     * 方法名称: updateTableIncreaseTimeMapFromDB
     *
     * @param
     * @return void  返回类型说明<br/>
     * @throws <br/>
     * @author liuwensheng@winning.com.cn<br/>
     * 创建时间：2016-12-13/下午4:42:20<br/>
     */
    public synchronized void updateTableIncreaseTimeMapFromDB(String dataSourseID) {
        tableIncreaseTimeMapFromDB = platBasicDataDao.getTableIncreaseTimeMapFromDB(dataSourseID);
    }

    /**
     * @param @param serviceID
     * @param @param serviceName
     * @param @param sql
     * @return void
     * @throws
     * @Title: saveMaxTBRQToDB
     * @Description: 只有当一次遍历完业务表数据后执行 ,将本地保存的业务表更新日期和SYS_SJSC_TABLE中的比对，更新SYS_SJSC_TABLE中的时间
     */
    public int saveMaxTBRQToDB(String moduleType, String serviceID, String serviceName, String sql, String dataSourseID) {
        //根据查询SQL，提取业务表名称和时间戳字段_TBRQ,从SYS_SJSC_TABLE中查询表的更新时间
        HashMap<String, String> tableValueMapFromSQL = SQLTool.getTableNameFromSQL(sql);

        //获取数据库中记录的增量更新时间记录
        HashMap<String, String> tableValueMapFromDB = getTableIncreaseTimeMapFromDB();

        //缓存业务数据中最新的填报日期
        HashMap<String, String> serviceDataMaxTBRQBuffTime = AppContext.getInstance().getTableLastTimeMapLocal();

        for (Entry<String, String> entry : tableValueMapFromSQL.entrySet()) {
            String tableName = entry.getKey();

            String mapKey = SQLTool.getTableMapKey(tableName, serviceID);

            //根据SQL中提供的表名称，从本地取得业务表中的最新的填报日期时间，保存到SYS_SJSC_TABLE
            String lastTimeValueFromLocal = serviceDataMaxTBRQBuffTime.get(mapKey) == null ? "1900-01-01 00:00:00" : serviceDataMaxTBRQBuffTime.get(mapKey);

            //本地最大时间，需要和SYS_SJSC_TABLE中记录的时间比较，才可以确定最后的日期
            String lastTimeValueFromDB = tableValueMapFromDB.get(mapKey) == null ? "1900-01-01 00:00:00" : tableValueMapFromDB.get(mapKey);


            LOGGER.info("--> lastTimeValueFromLocal = " + lastTimeValueFromLocal + "  | lastTimeValueFromDB = " + lastTimeValueFromDB);

            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            try {
                Date lastTimeValueFromDBDate = dateFormat.parse(lastTimeValueFromDB);
                Date lastTimeValueFromLocalDate = dateFormat.parse(lastTimeValueFromLocal);

                //如果本地时间大于数据库中保存的时间，则需要更新数据库时间
                if (lastTimeValueFromLocalDate.getTime() > lastTimeValueFromDBDate.getTime()) {
                    // 由于SYS_SJSC_TABLE中tableName字段存在主键唯一约束性，需要判断是做新增还是修改操作
                    platBasicDataDao.insertBusnisseLastTime(moduleType, serviceName, mapKey, lastTimeValueFromLocal, dataSourseID);
                } else {
                    /*
                     * 如果最新的业务时间，跟数据库中保存的增量时间一致，则说明同一个时间内的数据量过大，无法做增量处理
                     * 需要让分页查询向后再翻一页, 依次类推
                     */

                    return 1;
                }
            } catch (ParseException e) {
                e.printStackTrace();
                LOGGER.error(e.getMessage());
            }
        }

        //同步更新本地缓存的SYS_SJSC_TABLE中的数据
        updateTableIncreaseTimeMapFromDB(dataSourseID);

        return 0;
    }


    /**
     * 将医疗机构注册信息返回结果保存到数据库
     * 方法名称: saveYLJGXXRegisterResultToDB
     *
     * @param
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author zhaqiang@winning.com.cn<br/>
     * 创建时间：2017-3-6/下午4:46:27<br/>
     */
    public int saveYLJGXXRegisterResultToDB(Map<String, Object> prrb, String dataSourseID) {
        int result = -1;

        try {
            //填充信息
            Object[] params = new Object[prrb.size()];

            String sql = "INSERT INTO IHE_SYS_ZCJG_LOG (";

            //参数个数标记
            int index = 0;

            //根据个人信息map表动态填充insert语句
            for (Entry<String, Object> entry : prrb.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();

                sql += key + ",";

                params[index] = value;

                index++;

            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            //添加注册日期
            sql += " ZCRQ ";

            sql += ") VALUES (";

            for (int i = 0; i < index; i++) {
                sql += "?,";
            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            if (dataSourseID.indexOf(Constans.DATA_SOURCE_ORACLE_TAG) > -1) {
                //添加注册日期
                sql += " sysdate ";
            } else {
                sql += "GETDATE()";
            }

            sql += ")";

            result = platBasicDataDao.insertJBXXRegisterResult(sql, params, dataSourseID);
        } catch (Exception e) {
            //打印异常堆栈信息
            LOGGER.error(e);
            e.printStackTrace();
        }

        return result;
    }


    /**
     * 将科室信注册信息返回结果保存到数据库
     * 方法名称: saveYLJGXXRegisterResultToDB
     *
     * @param
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author zhaqiang@winning.com.cn<br/>
     * 创建时间：2017-3-6/下午4:46:27<br/>
     */
    public int saveKSXXRegisterResultToDB(Map<String, Object> prrb, String dataSourseID) {
        int result = -1;

        try {
            //填充信息
            Object[] params = new Object[prrb.size()];

            String sql = "INSERT INTO IHE_SYS_KSXX_LOG (";

            //参数个数标记
            int index = 0;

            //根据个人信息map表动态填充insert语句
            for (Entry<String, Object> entry : prrb.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();

                sql += key + ",";

                params[index] = value;

                index++;

            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            //添加注册日期
            sql += " ZCRQ ";

            sql += ") VALUES (";

            for (int i = 0; i < index; i++) {
                sql += "?,";
            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            if (dataSourseID.indexOf(Constans.DATA_SOURCE_ORACLE_TAG) > -1) {
                //添加注册日期
                sql += " sysdate ";
            } else {
                sql += "GETDATE()";
            }

            sql += ")";

            result = platBasicDataDao.insertJBXXRegisterResult(sql, params, dataSourseID);
        } catch (Exception e) {
            //打印异常堆栈信息
            LOGGER.error(e);
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 将基本信息注册返回结果保存到数据库
     * 方法名称: saveJBXXRegisterResultToDB
     *
     * @param
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author zq@winning.com.cn<br/>
     * 创建时间：Dec 22, 2016/3:33:05 PM<br/>
     */
    public int saveJBXXRegisterResultToDB(Map<String, Object> prrb, String dataSourseID) {

        int result = -1;

        try {
            //填充信息
            Object[] params = new Object[prrb.size()];

            String sql = "INSERT INTO IHE_GR_JBXX_LOG (";

            //参数个数标记
            int index = 0;

            //根据个人信息map表动态填充insert语句
            for (Entry<String, Object> entry : prrb.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();

                sql += key + ",";

                params[index] = value;

                index++;

            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            //添加注册日期
            sql += " ZCRQ ";

            sql += ") VALUES (";

            for (int i = 0; i < index; i++) {
                sql += "?,";
            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            if (dataSourseID.indexOf(Constans.DATA_SOURCE_ORACLE_TAG) > -1) {
                //添加注册日期
                sql += " sysdate ";
            } else {
                sql += "GETDATE()";
            }

            sql += ")";

            result = platBasicDataDao.insertJBXXRegisterResult(sql, params, dataSourseID);
        } catch (Exception e) {
            //打印异常堆栈信息
            LOGGER.error(e);
            e.printStackTrace();
        }

        return result;
    }


    /**
     * 将医护人员信息注册返回结果保存到数据库
     * 方法名称: saveYHRYRegisterResultToDB
     *
     * @param
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author zq@winning.com.cn<br/>
     * 创建时间：Dec 22, 2016/3:33:05 PM<br/>
     */
    public int saveYHRYRegisterResultToDB(Map<String, Object> prrb, String dataSourseID) {

        int result = -1;

        try {
            //填充信息
            Object[] params = new Object[prrb.size()];

            String sql = "INSERT INTO IHE_SYS_YHRY_LOG (";

            //参数个数标记
            int index = 0;

            //根据个人信息map表动态填充insert语句
            for (Entry<String, Object> entry : prrb.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();

                sql += key + ",";

                params[index] = value;

                index++;

            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            //添加注册日期
            sql += " ZCRQ ";

            sql += ") VALUES (";

            for (int i = 0; i < index; i++) {
                sql += "?,";
            }

            //去除最后一个  ，符号
            //sql = sql.substring(0,sql.length()-1);

            if (dataSourseID.indexOf(Constans.DATA_SOURCE_ORACLE_TAG) > -1) {
                //添加注册日期
                sql += " sysdate ";
            } else {
                sql += "GETDATE()";
            }

            sql += ")";

            result = platBasicDataDao.insertJBXXRegisterResult(sql, params, dataSourseID);
        } catch (Exception e) {
            //打印异常堆栈信息
            LOGGER.error(e);
            e.printStackTrace();
        }

        return result;
    }


    /**
     * 获取患者信息注册结果
     * 方法名称: queryGrRegisterResult
     *
     * @param
     * @return List<Map                                                                                                                                                                                                                                                               <                                                                                                                                                                                                                                                               String                                                                                                                                                                                                                                                               ,                                                                                                                                                                                                                                                               Object>>  返回类型说明<br/>
     * @throws <br/>
     * @author zq@winning.com.cn<br/>
     * 创建时间：2017-1-13/上午8:56:30<br/>
     */
    public List<HashMap<String, Object>> queryGrRegisterResult(String dbDataSourceID) {
        String sql = "select * from IHE_GR_JBXX_LOG where ZCJG = 'AA' and rownum = 1";

        try {
            List<HashMap<String, Object>> rs = platBasicDataDao.executeSQLByDataSourseID(sql, null, dbDataSourceID);

            return rs;
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.info(e.getMessage());
        }

        return null;
    }


    private static String ClobToString(Clob clob) {
        String reString = "";
        Reader is = null;
        BufferedReader br = null;
        try {
            is = clob.getCharacterStream();
            br = new BufferedReader(is);
            String s = br.readLine();
            StringBuffer sb = new StringBuffer();
            while (s != null) {
                sb.append(s);
                s = br.readLine();
            }
            reString = sb.toString();
        } catch (Exception e) {
            LOGGER.error(e, e.fillInStackTrace());
        } finally {
            try {
                is.close();
                br.close();
            } catch (IOException e) {
                LOGGER.error(e, e.fillInStackTrace());
                e.printStackTrace();
            }

        }

        return reString;
    }


    /**
     * 记录CDA注册返回结果
     * 方法名称: saveCDARegisterResponse
     *
     * @param
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author lenovo@winning.com.cn<br/>
     * 创建时间：2017-1-20/上午9:22:09<br/>
     */
    public int saveCDARegisterResponse(String SQL, String dbDataSourceID) {
        int result = -1;

        try {

            LOGGER.info("--> 记录CDA文档返回结果SQL:" + SQL);

            ServerSQLExecutorUtils.execute(SQL, null, dbDataSourceID);

            return 1;
        } catch (Exception e) {
            LOGGER.error(e, e.fillInStackTrace());
        }
        return result;
    }


    /**
     * 修改共享文档审计消息上传结果
     * 方法名称: saveAuditMessage
     *
     * @param
     * @return int  返回类型说明<br/>
     * @throws <br/>
     * @author lenovo@winning.com.cn<br/>
     * 创建时间：2017-1-24/上午9:28:44<br/>
     */
    public int saveAuditMessage(String id, String dbDataSourceID) {
        int result = -1;

        try {
            String sql = "update IHE_CDA_DOC_BUFFER set ISAUDIT = 'YES' WHERE UniqueId = '" + id + "'";

            LOGGER.info("-->审计结果更新SQL：" + sql);

            ServerSQLExecutorUtils.execute(sql, null, dbDataSourceID);

            return 1;
        } catch (Exception e) {
            LOGGER.error(e, e.fillInStackTrace());
        }

        return result;
    }


    public void resonseHandler(String responseXMLMessage, Map<String, Object> requestInfoMap, String dataSourseID) {

        //健康档案编号
        String id = requestInfoMap.get("ID").toString();

        LOGGER.info("-->进入CDA文档返回结果处理流程,处理编号:" + id);

        //修改CDA缓存表信息
        String updateSQL = "UPDATE IHE_CDA_DOC_BUFFER SET ";

        updateSQL = readDocumentSetResponseXMLHandler(responseXMLMessage, updateSQL);

        //去除最后一个，
        updateSQL = updateSQL.substring(0, updateSQL.length() - 1);


        //添加修改条件
        updateSQL += "WHERE id = '" + id + "'";

        int result = saveCDARegisterResponse(updateSQL, dataSourseID);

        if (result == 1) {
            LOGGER.info("--> CDA文档注册返回结果记录成功");
        } else {
            LOGGER.info("--> CDA文档注册返回结果记录失败");

        }


    }

    private String readDocumentSetResponseXMLHandler(String responseXMLMessage, String updateSQL) {
        //CDA文档上传返回ID的XPath路径
        final String XPATH_RESPONSE_ID = "xsi:Response/@id";

        //CDA文档上传状态XPath路径
        final String XPATH_RESPONSE_STATUS = "xsi:Response/@status";

        //CDA文档上传描述细节XPath路径
        final String XPATH_RESPONSE_DETAIL = "xsi:Response/xsi:Detail";

        //CDA文档上传响应消息ID
        final String XPATH_RESPONSE_OID = "xsi:Id/@extension";

        final String XPATH_RESPONSE_DOCUMENTURL = "xsi:Response/@doumentUrl";

        //CDA注册返回文档
        Document document = null;

        try {
            //将返回结果转换成xml文档对象
            document = XMLTool.getDocumentFromXMLString(responseXMLMessage, true);

            if (document != null) {
                //根节点
                Element root = document.getRootElement();

                //获取注册返回结果
                String status = XMLTool.selectAttributeValueByRootElement(root, XPATH_RESPONSE_STATUS);

                if (status != null && !status.equals("")) {
                    //将注册结果写入SQL
                    updateSQL += "ResponseStatus = '" + status + "',";

                    if (status.equals("AA")) {
                        //注册成功
                        String id = XMLTool.selectAttributeValueByRootElement(root, XPATH_RESPONSE_ID);

                        if (id != null && !id.equals("")) {
                            //将返回结果记录到SQL
                            updateSQL += "RepositoryId = '" + id + "',";
                        }


                        String documentUrl = XMLTool.selectAttributeValueByRootElement(root, XPATH_RESPONSE_DOCUMENTURL);

                        if (documentUrl != null && !documentUrl.equals("")) {
                            updateSQL += "doumentUrl = '" + documentUrl + "',";
                        }

                    } else {
                        //注册失败
                        String detail = XMLTool.selectElementValueByRootElement(root, XPATH_RESPONSE_DETAIL);

                        if (detail != null && !detail.equals("")) {
                            //将返回详细信息记录到SQL
                            updateSQL += "ResponseDetail = '" + detail + "',";
                        }
                    }
                }

                //返回消息id
                String responseId = XMLTool.selectAttributeValueByRootElement(root, XPATH_RESPONSE_OID);

                if (responseId != null && !responseId.equals("")) {
                    updateSQL += "ResponseId = '" + responseId + "',";
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error(e, e.fillInStackTrace());
        }
        return updateSQL;
    }


    /**
     * 根据上传服务ID获取数据源
     * 方法名称: getDBDataSouorceID
     *
     * @param
     * @return String  返回类型说明<br/>
     * @throws <br/>
     * @author zq@winning.com.cn<br/>
     * 创建时间：2017-2-7/上午10:51:45<br/>
     */
    private String getDBDataSouorceID(String serviceID) {
        String dbDataSourceID = "";
        //获取配置信息
        Map<String, XMLTempConfigBean> XMLTempConfigBeanMap = XMLTempBeanManager.getInstance().getXMLTempConfigBeanMap();

        //获取数据源
        for (Entry<String, XMLTempConfigBean> entity : XMLTempConfigBeanMap.entrySet()) {
            //一个模板接口配置任务
            XMLTempConfigBean xmlTempConfigBean = entity.getValue();

            //获取个人信息注册数据源
            if (xmlTempConfigBean.getServiceID().equals(serviceID)) {
                dbDataSourceID = xmlTempConfigBean.getDbDataSourseID();

                break;
            }
        }
        return dbDataSourceID;
    }


    /**
     * 根据serviceID获取定时配置对象
     * 方法名称: getServiceConfigBeanBy
     *
     * @param
     * @return XMLTempConfigBean  返回类型说明<br/>
     * @throws <br/>
     * @author zq@winning.com.cn<br/>
     * 创建时间：2017-2-7/上午11:03:30<br/>
     */
    public XMLTempConfigBean getServiceConfigBeanBy(String serviceID) {
        //获取配置信息
        Map<String, XMLTempConfigBean> XMLTempConfigBeanMap = XMLTempBeanManager.getInstance().getXMLTempConfigBeanMap();

        //获取数据源
        for (Entry<String, XMLTempConfigBean> entity : XMLTempConfigBeanMap.entrySet()) {
            //一个模板接口配置任务
            XMLTempConfigBean xmlTempConfigBean = entity.getValue();

            //获取个人信息注册数据源
            if (xmlTempConfigBean.getServiceID().equals(serviceID)) {
                return xmlTempConfigBean;
            }
        }

        return null;
    }


    /**
     * 生成Base64编码
     * 方法名称: getBASE64
     *
     * @param
     * @return String  返回类型说明<br/>
     * @throws <br/>
     * @author lenovo@winning.com.cn<br/>
     * 创建时间：2017-1-19/上午12:08:29<br/>
     */
    public static String getBASE64(String cdaContentValue) {
        String base64Str = "";

        if (cdaContentValue == null) {
            return null;
        }

        try {
            base64Str = (new sun.misc.BASE64Encoder()).encode(cdaContentValue.getBytes("UTF-8")).replace("\n", "").replace("\r", "");
        } catch (Exception e) {
            e.printStackTrace();
        }

        return base64Str;
    }

    /**
     * 根据定时器表达是获取下次生成时间
     * 方法名称: getTimeByTrigger
     *
     * @param
     * @return String  返回类型说明<br/>
     * @throws <br/>
     * @author zq@winning.com.cn<br/>
     * 创建时间：2017-2-7/下午5:05:22<br/>
     */
    private String getTimeByTrigger(String serviceID) {
        try {
            //获取下次定时上传执行时间
            XMLTempConfigBean xmlTempConfigBean = getServiceConfigBeanBy(serviceID);
            if (xmlTempConfigBean != null) {
                String time = xmlTempConfigBean.getJobExpressionValue();

                CronTrigger cronTriggerImpl = new CronTrigger();
                cronTriggerImpl.setCronExpression(time);//这里写要准备猜测的cron表达式

                Date now = new Date();

                //这个是重点，一行代码搞定~~
                List<Date> dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null, now.getDate());

                //System.out.println(dates.size());
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                if (dates != null && dates.size() != 0) {
                    return dateFormat.format(dates.get(0));

                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}
